﻿using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Reflection;
using System.Text.Json;
using System.Text.Json.Serialization;
using Common.Attributes;
using Common.Enums;
using Common.Exceptions;
using Common.Helper;

namespace Service.Converters
{
    /// <summary>
    /// 通用JSON转换器（支持嵌套对象和集合）
    /// </summary>
    public class GenericAwareConverter : JsonConverter<object>
    {
        private readonly IDictService _dictService;
        private readonly Dictionary<Type, List<PropertyInfo>> _propertieCache = new Dictionary<Type, List<PropertyInfo>>();
        // 用于内部反序列化的选项（排除当前转换器，避免递归）
        private JsonSerializerOptions _innerOptions;

        public GenericAwareConverter(IDictService dictService)
        {
            _dictService = dictService;
        }

        /// <summary>
        /// 支持所有引用类型（排除string，避免处理字符串）
        /// </summary>
        public override bool CanConvert(Type typeToConvert)
        {
            return typeToConvert.IsClass
                   && typeToConvert != typeof(string)
                   && !typeToConvert.IsAbstract; // 排除抽象类
        }

        /// <summary>
        /// 序列化核心逻辑（处理普通对象、嵌套对象、集合）
        /// </summary>
        public override void Write(Utf8JsonWriter writer, object value, JsonSerializerOptions options)
        {
            if (value == null)
            {
                writer.WriteNullValue();
                return;
            }

            // 1. 处理集合类型（List、IEnumerable等）
            if (value is IEnumerable enumerable && !(value is string))
            {
                writer.WriteStartArray();
                foreach (var item in enumerable)
                {
                    // 递归序列化集合中的每个元素
                    JsonSerializer.Serialize(writer, item, options);
                }

                writer.WriteEndArray();
                return;
            }

            // 2. 处理普通对象（包括嵌套对象如ResultData、PageData、UserInfoDto）
            var type = value.GetType();
            var properties = GetProperties(type);

            writer.WriteStartObject();
            foreach (var property in properties)
            {
                // 获取属性值（处理可能的null值）
                var propertyValue = property.GetValue(value);

                // 写入原始属性（递归处理嵌套对象）
                writer.WritePropertyName(property.Name);
                // 关键：传递options确保嵌套对象也使用当前转换器
                JsonSerializer.Serialize(writer, propertyValue, property.PropertyType, options);

                // 处理DictAttribute：生成新的JSON节点
                var dictAttr = property.GetCustomAttribute<ExtJsonAttribute>();
                if (dictAttr == null)
                {
                    continue;
                }

                // 生成目标属性名（默认规则：原属性名+Text）
                var targetPropName = string.IsNullOrEmpty(dictAttr.PropertyName)
                    ? $"{property.Name}Text"
                    : dictAttr.PropertyName;

                // 从数据字典查询文本（处理null值）
                var textValue = "";
                if (dictAttr.Type == ExtJsonEnum.Dict)
                {
                    var propertyValueStr = propertyValue?.ToString() ?? string.Empty;

                    textValue = string.IsNullOrEmpty(dictAttr.Code)
                        ? _dictService.GetTextByValue(propertyValueStr)
                        : _dictService.GetTextByParentCode(dictAttr.Code, propertyValueStr);
                }

                if (dictAttr.Type == ExtJsonEnum.Enums)
                {
                    if (!EnumHelper.IsEnum(propertyValue))
                    {
                        throw new CustomException(nameof(ExtJsonAttribute) + "需要添加在枚举属性类型上");
                    }

                    var enumTextByValue = EnumHelper.GetEnumTextByValue(propertyValue, typeof(DescriptionAttribute));
                    textValue = enumTextByValue;
                }

                // 写入新节点
                writer.WriteString(targetPropName, textValue);
            }

            writer.WriteEndObject();
        }
        
        /// <summary>
        /// 反序列化（保持默认行为）
        /// </summary>
        public override object Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            try
            {
                // 初始化内部选项（排除当前转换器）
                if (_innerOptions == null)
                {
                    _innerOptions = new JsonSerializerOptions(options);
                    // 移除当前转换器，避免递归调用
                    _innerOptions.Converters.Remove(this);
                }

                // 使用排除当前转换器的选项进行反序列化
                return JsonSerializer.Deserialize(ref reader, typeToConvert, _innerOptions);
            }
            catch (Exception e)
            {
                throw new CustomException($"反序列化失败：{e.Message}");
            }
        }
        
        /// <summary>
        /// 缓存属性信息（提升性能）
        /// </summary>
        private List<PropertyInfo> GetProperties(Type type)
        {
            if (_propertieCache.TryGetValue(type, out var props))
            {
                return props;
            }

            // 获取所有公共实例属性（排除索引器）
            var properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance)
                .Where(p => p.GetIndexParameters().Length == 0) // 排除索引器属性
                .ToList();
            Console.WriteLine($"获取属性信息：{type.Name}");
            _propertieCache[type] = properties;
            return properties;
        }
    }
}